home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / TEXT / CHAP05.TXT < prev    next >
Text File  |  1994-05-15  |  35KB  |  696 lines

  1.  
  2.  
  3.  
  4.                                                         Chapter 5
  5.                              FUNCTIONS, VARIABLES, AND PROTOTYPES
  6.  
  7. OUR FIRST USER DEFINED FUNCTION
  8. -----------------------------------------------------------------
  9. Load and examine the file SUMSQRES.C for an      ================
  10. example of a C program with functions.              SUMSQRES.C
  11. Actually this is not the first function we       ================
  12. have encountered because the main program we 
  13. have been using all along is technically a function, as is the 
  14. printf() function.  The printf() function is a library function 
  15. that was supplied with your compiler. 
  16.  
  17. Notice the executable part of this program which begins in line 8 
  18. with a line that simply says "header();", which is the way to 
  19. call any function.  The parentheses are required because the C 
  20. compiler uses them to determine that it is a function call and 
  21. not simply a misplaced variable.  When the program comes to this 
  22. line of code, the function named header() is called, its 
  23. statements are executed, and control returns to the statement 
  24. following this call.  Continuing on, we come to a for loop which 
  25. will be executed 7 times and which calls another function named 
  26. square() each time through the loop, and finally a function named 
  27. ending() will be called and executed.  For the moment ignore the 
  28. variable name index in the parentheses of the call to square.  We 
  29. have seen that this program calls a header, 7 square calls, and 
  30. an ending.  Now we need to define the functions.
  31.  
  32.  
  33. DEFINING THE FUNCTIONS
  34. -----------------------------------------------------------------
  35. Following the main program you will see another program beginning 
  36. in line 14 that follows all of the rules set forth so far for a 
  37. main program except that it is named header().  This is the 
  38. function which is called from line 8 of the main program.  Each 
  39. of these statements are executed, and when they are all complete, 
  40. control returns to the main program.  The first statement sets the 
  41. variable named sum equal to zero because we plan to use it to 
  42. accumulate a sum of squares.  Since the variable named sum is 
  43. defined prior to the main program, it is available for use in any 
  44. of the functions which are defined after the variable is defined.  
  45. It is called a global variable, and its scope is the entire 
  46. program including all functions.  It is also sometimes referred 
  47. to as a file variable because it is available throughout the 
  48. file.  More will be said about the scope of variables near the 
  49. end of this chapter.  The statement in line 17 outputs a header 
  50. message to the monitor.  Program control then returns to the main 
  51. program since there are no additional statements to execute in 
  52. this function.  Essentially, we drop out of the bottom of the 
  53. function and return to the caller.
  54.  
  55.  
  56.  
  57.                                                          Page 5-1
  58.  
  59.                  Chapter 5 - Functions, Variables, and Prototypes
  60.  
  61. It should be clear to you that the two executable lines from this 
  62. function could be moved to the main program, replacing the header 
  63. call, and the program would do exactly the same thing that it 
  64. does as it is now written.  This does not minimize the value of 
  65. functions, it merely illustrates the operation of this simple 
  66. function in a simple way.  You will find functions to be very 
  67. valuable in C programming.
  68.  
  69.  
  70. PASSING A VALUE TO A FUNCTION (CLASSIC METHOD)
  71. -----------------------------------------------------------------
  72. Going back to the main program, and the for loop specifically, we 
  73. find the new construct from the end of the last lesson used in 
  74. the last part of the for loop, namely the index++ used in line 9.  
  75. You should get familiar with this construct, as you will see it 
  76. in a lot of C programs.  In the call to the function named 
  77. square(), we have an added feature, the variable name index 
  78. within the parentheses.  This is an indication to the compiler 
  79. that when you jump to the function, you wish to take along the 
  80. value of index to use in the execution of that function.  Looking 
  81. ahead at the function named square() in line 20, we find that 
  82. another variable name is enclosed in its parentheses, the 
  83. variable number.  This is the name we prefer to call the variable 
  84. passed to the function when we are in the function.  We can call 
  85. it anything we wish as long as it follows the rules of naming an 
  86. identifier.  Since the function must know what type the variable 
  87. is, it is defined following the function name but before the 
  88. opening brace of the function itself.  Therefore, line 21 
  89. containing the expression "int number;" tells the function that 
  90. the value passed to it will be an integer type variable.  With 
  91. all of that out of the way, we now have the value of index from 
  92. the main program passed to the function square(), but renamed 
  93. number, and available for use within the function.  This is the 
  94. classic style of defining function variables and has been in use 
  95. since C was originally defined.  A newer, and much better, method 
  96. is gaining in popularity due to its many benefits and will be 
  97. discussed later in this chapter.
  98.  
  99. Following the opening brace of the function, we define another 
  100. variable named numsq for use only within the function itself, 
  101. (more about that later) and proceed with the required 
  102. calculations.  We set the variable named numsq equal to the 
  103. square of the value of number, then add numsq to the current 
  104. total stored in the variable named sum.  You should remember 
  105. that the expression "sum += numsq;" has the same meaning as 
  106. "sum = sum + numsq;" from the last lesson.  We print the number 
  107. and its square in line 27, and return to the main program.
  108.  
  109.  
  110. MORE ABOUT PASSING A VALUE TO A FUNCTION
  111. -----------------------------------------------------------------
  112. When we passed the value of the variable named index to the 
  113. function, a little more happened than meets the eye.  We didn't 
  114.  
  115.                                                          Page 5-2
  116.  
  117.                  Chapter 5 - Functions, Variables, and Prototypes
  118.  
  119. pass the variable named index to the function, we actually passed 
  120. a copy of the value.  In this way the original value is protected 
  121. from accidental corruption by the called function.  We could have 
  122. modified the variable named number in any way we wished in the 
  123. function named square(), and when we returned to the main 
  124. program, the variable named index would not have been modified.  
  125. We thus protect the value of a variable in the calling function 
  126. from being accidentally corrupted, but we cannot return a value 
  127. to the calling function from a called function using this 
  128. technique.  We will find a well defined method of returning 
  129. values to the main program or to any calling function when we get 
  130. to arrays and another method when we get to pointers.  Until 
  131. then, the only way you will be able to communicate back to the 
  132. calling function will be with global variables.  We have already 
  133. hinted at global variables above, and will discuss them in detail 
  134. later in this chapter.
  135.  
  136. Continuing in the main program, we come to the last function 
  137. call, the call to the function named ending() in line 11.  This 
  138. line calls the last function which has no local variables
  139. defined.  It prints out a message with the value of the variable 
  140. sum contained in it to end the program.  The program ends by 
  141. returning to the main program and finding nothing else to do.  
  142. Compile and run this program and observe the output.
  143.  
  144.  
  145. NOW TO CONFESS A LITTLE LIE
  146. -----------------------------------------------------------------
  147. I told you a short time ago that the only way     ===============
  148. to get a value back to the main program was          SQUARES.C
  149. through use of a global variable, but there is    ===============
  150. another way which we will discuss after you 
  151. load and display the program named SQUARES.C.  In this example 
  152. program we will see that it is simple to return a single value 
  153. from a called function to the calling function.  But once again, 
  154. it is true that to return more than one value, we will need to 
  155. study either arrays or pointers.
  156.  
  157. In the main program, we define two integers and begin a for loop 
  158. in line 6 which will be executed 8 times.  The first statement of 
  159. the for loop is "y = squ(x);", which is a new and rather strange 
  160. looking construct.  From past experience, we should have no 
  161. trouble understanding that the squ(x) portion of the statement is 
  162. a call to the function named squ() taking along the value of x as 
  163. a variable.  Looking ahead to line 15 of the function itself, we 
  164. find that the function prefers to call the input variable input, 
  165. and it proceeds to square the value of input and call the result 
  166. square.  Finally, a new kind of a statement appears in line 21, 
  167. the return statement.  The value within the parentheses is 
  168. assigned to the function itself and is returned as a usable value 
  169. in the main program.  Thus, the function call "squ(x)" is 
  170. assigned the value of the square and returned to the main program 
  171. such that the variable named y is then set equal to that value.  
  172.  
  173.                                                          Page 5-3
  174.  
  175.                  Chapter 5 - Functions, Variables, and Prototypes
  176.  
  177. If the variable named x were therefore assigned the value 4 prior 
  178. to this call, y would then be set to 16 as a result of the code 
  179. in line 7.
  180.  
  181. Another way to think of this is to consider the grouping of 
  182. characters squ(x) as another variable with a value that is the 
  183. square of x, and this new variable can be used any place it is 
  184. legal to use a variable of its type.  The values of the variables 
  185. x and y are then printed out.
  186.  
  187. To illustrate that the grouping of squ(x) can be thought of as 
  188. just another variable, another for loop is introduced in line 11 
  189. in which the function call is placed in the printf() statement 
  190. rather than assigning it to a new variable.
  191.  
  192. One last point must be made, the type of variable returned must 
  193. be defined in order to make sense of the data, but the compiler 
  194. will default the type to int if none is specified.  If any other 
  195. type is desired, it must be explicitly defined.  How to do this 
  196. will be demonstrated in the next example program.  We are simply 
  197. using the default return value in this program.
  198.  
  199. Be sure to compile and run this program which also uses the 
  200. classic method of defining function variables.  Once again, any 
  201. warnings can be ignored.
  202.  
  203.  
  204. FLOATING POINT FUNCTIONS
  205. -----------------------------------------------------------------
  206. Load the program FLOATSQ.C for an example of a    ===============
  207. function with a floating point type of return.       FLOATSQ.C
  208. It begins by defining a global floating point     ===============
  209. variable named z which we will use later.  
  210. Then in the main part of the program, an integer is defined, 
  211. followed by two floating point variables, and then by two strange 
  212. looking definitions.  The expressions sqr() and glsqr() look like 
  213. function calls and they are.  This is the proper way in C to 
  214. define that a function will return a value that is not of type 
  215. int, but of some other type, in this case float.  This tells the 
  216. compiler that when a value is returned from either of these two 
  217. functions, it will be of type float.  This is, once again, the 
  218. classic method of defining functions and is all but obsolete now.
  219.  
  220. Now refer to the function named sqr() starting in line 22 and you 
  221. will see that the function name is preceded by the keyword float.  
  222. This is an indication to the compiler that this function will 
  223. return a value of type float to any program that calls it.  The 
  224. type of the function return is now compatible with the call to 
  225. it.  The line following the function name contains float inval;, 
  226. which indicates to the compiler that the variable passed to this 
  227. function from the calling program will be of type float.
  228.  
  229.  
  230.  
  231.                                                          Page 5-4
  232.  
  233.                  Chapter 5 - Functions, Variables, and Prototypes
  234.  
  235. The function named glsqr() beginning in line 31, will also return 
  236. a float type variable, but it uses a global variable for input.  
  237. It does the squaring right within the return statement and 
  238. therefore has no need to define a separate variable to store the 
  239. product.
  240.  
  241. The overall structure of this program should pose no problem and 
  242. will not be discussed in any further detail.  As is customary 
  243. with all example programs, compile and run this program.
  244.  
  245.  
  246. THE CLASSIC STYLE
  247. -----------------------------------------------------------------
  248. The three programs we have studied in this chapter so far use the 
  249. classic style of function definition.  Although this was the 
  250. first style defined for C, it is rapidly being replaced with a 
  251. more modern method of function definition because the modern 
  252. method does so much for you in detecting and flagging errors.  
  253. As you read articles on C, you will see programs written in the 
  254. classic style, so you need to be capable of reading them.  This 
  255. is the reason the classic style was included in this chapter.  It 
  256. would be highly recommended, however, that you learn and use the 
  257. modern method which will be covered shortly in this tutorial.  In 
  258. fact, you are advised to never use the classic style for any of 
  259. your programming efforts.
  260.  
  261. The remainder of this tutorial will use the modern method as 
  262. recommended and defined by the ANSI standard.  If you have an 
  263. older compiler, it may not work on some of these files and it 
  264. will be up to you to modify the programs as needed to conform to 
  265. the classic style.  Actually, the ANSI standard is used so 
  266. universally, if you have a non-ANSI compiler you should use it 
  267. only as a doorstop and purchase a good ANSI compatible compiler 
  268. for the rest of your studies.
  269.  
  270.  
  271. SCOPE OF VARIABLES
  272. -----------------------------------------------------------------
  273. Load the next program, SCOPE.C, and display it    ===============
  274. for a discussion of the scope of variables in a       SCOPE.C
  275. program.  You can ignore the 4 statements in      ===============
  276. lines 2 through 5 of this program for a few 
  277. moments.  We will discuss them later.
  278.  
  279. The variable defined in line 7 is a global variable named count 
  280. which is available to any function in the program since it is 
  281. defined before any of the functions.  It is always available 
  282. because it exists during all the time that the program is being 
  283. executed.  (That will make sense shortly.)  Farther down in the 
  284. program, another global variable named counter is defined in line 
  285. 25 which is also global but is not available to the main program 
  286. since it is defined following the main program.  A global 
  287. variable is any variable that is defined outside of any function.  
  288.  
  289.                                                          Page 5-5
  290.  
  291.                  Chapter 5 - Functions, Variables, and Prototypes
  292.  
  293. Note that both of these variables are sometimes referred to as 
  294. external variables because they are external to any functions, 
  295. and they are sometimes also called file variables.
  296.  
  297. Return to the main program and you will see the variable named 
  298. index defined as an integer in line 11.  Ignore the word register 
  299. for the moment.  This variable is only available within the main 
  300. program because that is where it is defined.  In addition, it is 
  301. an automatic variable, which means that it only comes into 
  302. existence when the function in which it is contained is invoked, 
  303. and ceases to exist when the function is finished.  This really 
  304. means nothing here because the main program is always in 
  305. operation, even when it gives control to another function.  
  306. Another integer is defined within the for loop braces named 
  307. stuff.  Any pairing of braces can contain variable definitions 
  308. which will be valid and available only while the program is 
  309. executing statements within those braces.  The variables will be 
  310. automatic variables and will cease to exist when execution leaves 
  311. the braces.  This is convenient to use for a loop counter or some 
  312. other very localized variable.
  313.  
  314.  
  315. MORE ON AUTOMATIC VARIABLES
  316. -----------------------------------------------------------------
  317. Observe the function named head1() in line 26 which looks a 
  318. little funny because of void being used twice.  The purpose of 
  319. the use of the word void will be explained shortly. The function 
  320. contains a variable named index, which has nothing to do with the 
  321. variable named index in line 11 of the main program, except that 
  322. both are automatic variables.  When the program is not actually 
  323. executing statements in this function, this variable named index 
  324. does not even exist.  When head1() is called, the variable is 
  325. generated, and when head1() completes its task, the variable in 
  326. head1() named index is eliminated completely from existence.  
  327. (The automatic variable is stored on the stack.  This topic will 
  328. be covered later.)  Keep in mind however that this does not 
  329. affect the variable of the same name in the main program, since 
  330. it is a completely separate entity.
  331.  
  332. Automatic variables therefore, are automatically generated and 
  333. disposed of when needed.  The important thing to remember is that 
  334. from one call of a function to the next call, the value of an 
  335. automatic variable is not preserved and must therefore be 
  336. reinitialized.
  337.  
  338.  
  339. WHAT ARE STATIC VARIABLES?
  340. -----------------------------------------------------------------
  341. An additional variable type must be mentioned at this point, the 
  342. static variable.  By putting the keyword static in front of a 
  343. variable definition within a function, the variable or variables 
  344. in that definition are static variables and will stay in 
  345. existence from call to call of the particular function.  A static 
  346.  
  347.                                                          Page 5-6
  348.  
  349.                  Chapter 5 - Functions, Variables, and Prototypes
  350.  
  351. variable is initialized once, at load time, and is never 
  352. reinitialized during execution of the program.
  353.  
  354. By putting the static keyword in front of an external variable, 
  355. one outside of any function, it makes the variable private and 
  356. not accessible to use in any other file.  (This is a completely 
  357. different use of the same keyword.)  This implies that it is 
  358. possible to refer to external variables in other separately 
  359. compiled files, and that is true.  Examples of this usage will be 
  360. given in chapter 14 of this tutorial.
  361.  
  362.  
  363. USING THE SAME NAME AGAIN
  364. -----------------------------------------------------------------
  365. Refer to the function named head2().  It contains another 
  366. definition of the variable named count.  Even though count has 
  367. already been defined as a global variable in line 7, it is 
  368. perfectly all right to reuse the name in this function.  It is a 
  369. completely new variable that has nothing to do with the global 
  370. variable of the same name, and causes the global variable to be 
  371. unavailable within this function.  This allows you to write 
  372. programs using existing functions without worrying about what 
  373. names were used for global variables or in other functions 
  374. because there can be no conflict.  You only need to worry about 
  375. the variables that interface with the functions.
  376.  
  377.  
  378. WHAT IS A REGISTER VARIABLE?
  379. -----------------------------------------------------------------
  380. Now to fulfill a promise made earlier about what a register 
  381. variable is.  A computer can keep data in a register or in 
  382. memory.  A register is much faster in operation than memory but 
  383. there are very few registers available for the programmer to use.  
  384. If there are certain variables that are used extensively in a 
  385. program, you can designate that those variables are to be stored 
  386. in a register in order to speed up the execution of the program.  
  387. The method of doing this is illustrated in line 11.  Your 
  388. compiler probably allows you to use one or more register 
  389. variables and will ignore additional requests if you request more 
  390. than are available.  The documentation for your compiler should 
  391. list how many registers are available with your compiler.  It 
  392. will also inform you of what types of variables can be stored in 
  393. a register.  If your compiler does not allow the use of register 
  394. variables, the register request will simply be ignored.
  395.  
  396.  
  397. WHERE DO I DEFINE VARIABLES?
  398. -----------------------------------------------------------------
  399. Now for a refinement on a general rule stated earlier.  When you 
  400. have variables brought to a function as arguments to the 
  401. function, and you are using the classic style of programming, 
  402. they are defined immediately after the function name and prior to 
  403. the opening brace for the executable statements.  Local variables 
  404.  
  405.                                                          Page 5-7
  406.  
  407.                  Chapter 5 - Functions, Variables, and Prototypes
  408.  
  409. used in the function are defined at the beginning of the 
  410. function, immediately following the opening brace of the 
  411. function, and before any executable statements.
  412.  
  413.  
  414. WHAT IS PROTOTYPING?
  415. -----------------------------------------------------------------
  416. A prototype is a model of a real thing and when programming with 
  417. a good up-to-date C compiler, you have the ability to define a 
  418. model of each function for the compiler.  The compiler can then 
  419. use the model to check each of your calls to the function and 
  420. determine if you have used the correct number of arguments in the 
  421. function call and if they are of the correct type.  By using 
  422. prototypes, you let the compiler do some additional error 
  423. checking for you.  The ANSI standard for C contains prototyping 
  424. as part of its recommended standard.  Every good C compiler will 
  425. have prototyping available, so you should learn to use it.  Much 
  426. more will be said about prototyping throughout the remainder of 
  427. this tutorial.
  428.  
  429. Returning to lines 3, 4, and 5 in SCOPE.C, we have the prototypes 
  430. for the three functions contained within the program.  The first 
  431. void in each line tells the compiler that these particular 
  432. functions do not return a value, so that the compiler would flag 
  433. the statement index = head1(); as an error because nothing is 
  434. returned to assign to the variable named index.  The word void 
  435. within the parentheses tells the compiler that this function 
  436. requires no parameters and if a variable were included, it would 
  437. be an error and the compiler would issue a warning message.  If 
  438. you wrote the statement head1(index);, it would be a error.  This 
  439. allows you to use type checking when programming in C in much the 
  440. same manner that it is used in Pascal, Modula-2, or Ada, although 
  441. the type checking in C is relatively weak.
  442.  
  443. Note the addition of the word void in line 9.  This is an 
  444. indication to the system that we do not plan to return a value to 
  445. the operating system when we terminate operation of this program.  
  446. The main program also can return an int value in the same manner 
  447. as any other function.  This value is returned to the operating 
  448. system where it can be ignored or it's value used as an 
  449. indication of what the program did.
  450.  
  451. You may have been getting warning messages when you compiled many 
  452. of the example programs in this tutorial, and you now see the 
  453. reasons for these warnings.  The compiler was telling you that it 
  454. did not know how to handle the lack of a return definition.  This 
  455. will be fixed in all of the remaining example programs in this 
  456. tutorial.
  457.  
  458. You should begin using prototype checking at this time, if it is 
  459. available with your compiler.  Your compiler may have an option 
  460. that will require a prototype for every function.  This should be 
  461. enabled and left enabled.  Check your documentation for the 
  462.  
  463.                                                          Page 5-8
  464.  
  465.                  Chapter 5 - Functions, Variables, and Prototypes
  466.  
  467. details of how to do it.  Prototyping will be used throughout the 
  468. remainder of this tutorial.  If your compiler does not support 
  469. prototyping and the modern method of function definition, you 
  470. will have to modify the remaining example programs.  A much 
  471. better solution would be to purchase a better compiler.
  472.  
  473. Line 2 of SCOPE.C tells the system to go to the standard 
  474. directory where include files are stored and get the file named 
  475. STDIO.H which contains the prototypes for the standard input and 
  476. output functions so they can be checked for proper variable 
  477. types.  Don't worry about the include yet, it will be covered in 
  478. detail later in this tutorial.  Be sure to compile and execute 
  479. this program.  If you have been getting warnings about the 
  480. function printf() not being defined, it is fixed by including 
  481. the stdio.h file as we have done here.  We will explain why this 
  482. fixes the warnings shortly.
  483.  
  484.  
  485. STANDARD FUNCTION LIBRARIES
  486. -----------------------------------------------------------------
  487. Every compiler comes with some standard predefined functions 
  488. which are available for your use.  These are mostly input/output 
  489. functions, character and string manipulation functions, and math 
  490. functions.  We will cover most of these in subsequent chapters.  
  491. Prototypes are defined for you by the writer of your compiler for 
  492. all of the functions that are included with your compiler.  A few 
  493. minutes spent studying your reference guide will give you an 
  494. insight in where the prototypes are defined for each of the 
  495. functions.
  496.  
  497. Most compilers have additional functions predefined that are not 
  498. standard but allow the programmer to get the most out of his 
  499. particular computer.  In the case of the IBM-PC and compatibles, 
  500. most of these functions allow the programmer to use the BIOS 
  501. services available in the operating system, or to write directly 
  502. to the video monitor or to any place in memory.  These will not 
  503. be covered in any detail as you will be able to study these 
  504. unique aspects of your compiler on your own.  Several of these 
  505. kinds of functions are used in the example programs in chapter 
  506. 14.
  507.  
  508.  
  509. WHAT IS RECURSION?
  510. -----------------------------------------------------------------
  511. Recursion is another of those programming        ================
  512. techniques that seem very intimidating the          RECURSON.C
  513. first time you come across it, but if you will   ================
  514. load and display the example program named 
  515. RECURSON.C, we will take all of the mystery out of it.  This is 
  516. probably the simplest recursive program that it is possible to 
  517. write and it is therefore a stupid program in actual practice, 
  518. but for purposes of illustration, it is excellent.
  519.  
  520.  
  521.                                                          Page 5-9
  522.  
  523.                  Chapter 5 - Functions, Variables, and Prototypes
  524.  
  525. Recursion is nothing more than a function that calls itself.  It 
  526. is therefore in a loop which must have a way of terminating.  In 
  527. the program on your monitor, the variable named index is set to 8 
  528. in line 9, and is used as the argument to the function named 
  529. count_dn().  The function simply decrements the variable, prints 
  530. it out in a message, and if the variable is not zero, it calls 
  531. itself, where it decrements the variable again, prints it, etc. 
  532. etc. etc.  Finally, the variable will reach zero, and the 
  533. function will not call itself again.  Instead, it will return to 
  534. the prior time it called itself, and return again, and again, 
  535. until finally it will return to the main program and from there 
  536. return to DOS.
  537.  
  538. For purposes of understanding you can think of it as having 8 
  539. copies of the function named count_dn() available and it simply 
  540. called all of them one at a time, keeping track of which copy it 
  541. was in at any given time.  That is not what actually happened, 
  542. but it is a reasonable illustration for you to begin 
  543. understanding what it was really doing.
  544.  
  545.  
  546. WHAT DID IT DO?
  547. -----------------------------------------------------------------
  548. A better explanation of what actually happened is in order.  When 
  549. you called the function from itself, it stored all of the 
  550. variables and all of the internal flags it needs to complete the 
  551. function in a block somewhere.  The next time it called itself, 
  552. it did the same thing, creating and storing another block of 
  553. everything it needed to complete that function call.  It 
  554. continued making these blocks and storing them away until it 
  555. reached the last function when it started retrieving the blocks 
  556. of data, and using them to complete each function call.  The 
  557. blocks were stored on an internal part of the computer called the 
  558. stack.  This is a part of memory carefully organized to store 
  559. data just as described above.  It is beyond the scope of this 
  560. tutorial to describe the stack in detail, but it would be good 
  561. for your programming experience to read some material describing 
  562. the stack.  A stack is used in nearly all modern computers for 
  563. internal housekeeping chores.
  564.  
  565. In using recursion, you may desire to write a program with 
  566. indirect recursion as opposed to the direct recursion described 
  567. above.  Indirect recursion would be when a function A calls the 
  568. function B, which in turn calls A, etc.  This is entirely 
  569. permissible, the system will take care of putting the necessary 
  570. things on the stack and retrieving them when needed again.  There 
  571. is no reason why you could not have three functions calling each 
  572. other in a circle, or four, or five, etc.  The C compiler will 
  573. take care of all of the details for you.
  574.  
  575. The thing you must remember about recursion is that at some 
  576. point, something must go to zero, or reach some predefined point 
  577. to terminate the loop.  If not, you will have an infinite loop, 
  578.  
  579.                                                         Page 5-10
  580.  
  581.                  Chapter 5 - Functions, Variables, and Prototypes
  582.  
  583. and the stack will fill up and overflow, giving you an error and 
  584. stopping the program rather abruptly.
  585.  
  586.  
  587. ANOTHER EXAMPLE OF RECURSION
  588. -----------------------------------------------------------------
  589. The program named BACKWARD.C is another example    ==============
  590. of recursion, so load it and display it on your      BACKWARD.C
  591. screen at this time.  This program is similar      ==============
  592. to the last one except that it uses a character 
  593. array.  Each successive call to the function named 
  594. forward_and_backwards() causes one character of the message to be 
  595. printed.  Additionally, each time the function ends, one of the 
  596. characters is printed again, this time backwards as the string of 
  597. recursive function calls is retraced.
  598.  
  599. This program uses the modern method of function definition and 
  600. includes full prototype definitions.  The modern method of 
  601. function definition moves the types of the variables into the 
  602. parentheses along with the variable names themselves.  The final 
  603. result is that the line containing the function definition looks 
  604. more like the corresponding line in a language with relatively 
  605. strong type checking such as Pascal, Modula-2, or Ada.  The 
  606. prototype in line 5 is simply a copy of the function header in 
  607. line 18 followed by a semicolon.  The designers of C even allow 
  608. you to include a variable name along with each type.  The name is 
  609. ignored by the compiler but including the name in the prototype 
  610. could give you a good idea of how the variable is used, acting 
  611. like a comment.
  612.  
  613. Don't worry about the character array defined in line 9 or the 
  614. other new material presented here.  After you complete chapter 7 
  615. of this tutorial, this program will make sense.  It was felt that 
  616. introducing a second example of recursion was important so this 
  617. file is included here.
  618.  
  619. Compile and run this program with prototype checking enabled and 
  620. observe the results.
  621.  
  622.  
  623. THE FLOAT SQUARE PROGRAM WITH PROTOTYPES
  624. -----------------------------------------------------------------
  625. Load and display the program named FLOATSQ2.C    ================
  626. which is an exact copy of the program FLOATSQ.C     FLOATSQ2.C
  627. which we considered earlier with prototyping     ================
  628. added.  The use of prototyping is a good 
  629. practice for all C programmers to get into.  Several things 
  630. should be mentioned about this program.  First, the word float at 
  631. the beginning of lines 27 and 35 indicate to the compiler that 
  632. these functions are functions that return float type values.  
  633. Also, since the prototypes are given before main, the functions 
  634. are not required to be identified in line 12 as they were in line 
  635. 7 of FLOATSQ.C earlier in this chapter.  Notice also that the 
  636.  
  637.                                                         Page 5-11
  638.  
  639.                  Chapter 5 - Functions, Variables, and Prototypes
  640.  
  641. type of the variable named inval is included within the 
  642. parentheses in line 27.
  643.  
  644. Now that we understand prototypes, we can eliminate most of the 
  645. warnings we have been getting during our study of this tutorial.  
  646. It would be good practice for you to eliminate all warnings in 
  647. all of your programs, since the compiler is trying to warn you of 
  648. some potentially bad programming constructs.
  649.  
  650.  
  651. MORE STYLE ISSUES
  652. -----------------------------------------------------------------
  653. The example named STYLE2.C is given as an        ================
  654. illustration of various ways to format a             STYLE2.C
  655. function.  You will note different ways to       ================
  656. define the input parameters.  Examples three 
  657. and four are both the same style, but example four illustrates 
  658. the style when nothing is passed in or returned.  This style 
  659. states very clearly that nothing is needed or returned and it 
  660. cannot be construed as an oversight.  Spend some time studying 
  661. these function examples, then begin developing the style you will 
  662. use.  If you are like most programmers, you will develop a style 
  663. that you plan to use forever, then change it every few months or 
  664. on every new project.
  665.  
  666.  
  667. PROGRAMMING EXERCISES
  668. -----------------------------------------------------------------
  669. 1.  Rewrite  TEMPCONV.C, from an earlier chapter, and move the 
  670.     temperature calculation to a function.
  671.     
  672. 2.  Write a program that writes your name on the monitor 10 times 
  673.     by calling a function to do the writing. Move the called 
  674.     function ahead of the main function to see if your C compiler 
  675.     will allow it.
  676.  
  677. 3.  Add prototyping to the programs named SUMSQRES.C and 
  678.     SQUARES.C, and change the function definitions to the modern 
  679.     method.
  680.  
  681.  
  682.  
  683.  
  684.  
  685.  
  686.  
  687.  
  688.  
  689.  
  690.  
  691.  
  692.  
  693.  
  694.  
  695.                                                         Page 5-12
  696.